home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / dev / e / e_modules02.lha / e_modules02 / mempools / modules / tools / MemPools.e next >
Encoding:
Text File  |  1996-07-23  |  4.7 KB  |  195 lines
  1. OPT MODULE
  2. OPT PREPROCESS,REG=5
  3.  
  4. ->#define DEBUG
  5. ->#define TEST   -> for tests under OS v39+
  6.  
  7. MODULE 'exec/memory','exec/lists','exec/nodes','exec/execbase',
  8.        'amigalib/lists'
  9. #ifdef DEBUG
  10. MODULE 'tools/debug'
  11. #endif
  12.  
  13. /*
  14.   Pools.c 1.0 (11.97.94) © D. Göhler
  15.   This source was *NEVER* tested and just typed in from the
  16.   Amiga magazine, 10/94. Handle it with care.
  17.   Adapted to match the definitions of LibAllocPooled() and
  18.   LibFreePooled() by Jochen Wiedmann.
  19.  
  20.   $VER: mempools v1.2 (19.07.96) AmigaE version by Piotr Gapiïski
  21.   v1.1 (20.04.96) - first conversion
  22.                   - added libAllocVecPooled() and libFreeVecPooled()
  23.   v1.2 (19.07.96) - fixed problem with libAllocPooled()
  24. */
  25.  
  26. /**
  27. ***  The structure used for a pool.
  28. **/
  29. EXPORT OBJECT pool
  30.   mhanchor:lh           /*  Puddle list                         */
  31.   flags:LONG            /*  AllocMem argument                   */
  32.   puddlesize:LONG       /*  Usual puddle size                   */
  33.   treshsize:LONG        /*  Size that requires a special puddle */
  34. ENDOBJECT
  35.  
  36. /**
  37. ***  AllocMemHeader() allocates a new block of RAM from the global
  38. ***  memory list.
  39. **/
  40. PROC allocMemHeader(size,flags)
  41.   DEF mh:REG PTR TO mh,
  42.       mc:REG PTR TO mc
  43.  
  44.   mh:=AllocMem(size + SIZEOF mh,flags)
  45.   IF mh<>NIL
  46.     mc:=mh+SIZEOF mh
  47.     mc.next:=NIL
  48.     mc.bytes:=size
  49.  
  50.     mh::ln.type:=NT_MEMORY
  51.     mh::ln.name:=NIL
  52.     mh::ln.succ:=NIL
  53.     mh::ln.pred:=NIL
  54.     mh::ln.pri:=0
  55.     mh.first:=mc
  56.     mh.lower:=mc
  57.     mh.upper:=mc+size
  58.     mh.free:=size
  59.   ENDIF
  60. ENDPROC mh
  61.  
  62. /**
  63. ***  FreeMemHeader() is the counterpart of AllocMemHeader().
  64. **/
  65. PROC freeMemHeader(mh:PTR TO mh)
  66.   IF mh<>NIL THEN  FreeMem(mh,mh.upper-mh.lower+SIZEOF mh)
  67. ENDPROC
  68.  
  69. /**
  70. ***  LibCreatePool() is the CreatePool() equivalent. In fact, it calls
  71. ***  CreatePool(), if the OS is V39 or higher.
  72. **/
  73. EXPORT PROC libCreatePool(flags,puddlesize,treshsize)
  74.   DEF pool=NIL:REG PTR TO pool
  75.  
  76. #ifndef TEST
  77.   IF KickVersion(39) THEN RETURN CreatePool(flags,puddlesize,treshsize)
  78. #endif
  79.   IF treshsize <= puddlesize
  80.     IF (pool:=AllocMem(SIZEOF pool,MEMF_ANY))<>NIL
  81.       pool.flags:=flags
  82.       pool.puddlesize:=puddlesize
  83.       pool.treshsize:=treshsize
  84.       newList(pool::lh)
  85.       pool::lh.type:=NT_MEMORY
  86.       #ifdef DEBUG
  87.         kputfmt('MEMPOOL created at $\h, flags=$\h, puddle=$\h, tresh=$h\n',
  88.                 [pool,pool.flags,pool.puddlesize,pool.treshsize])
  89.       #endif
  90.     ENDIF
  91.   ENDIF
  92. ENDPROC pool
  93.  
  94. /**
  95. ***  LibDeletePool() is the counterpart of LibCreatePool().
  96. **/
  97. EXPORT PROC libDeletePool(pool: PTR TO pool)
  98.   DEF mh:PTR TO mh
  99.  
  100. #ifndef TEST
  101.   IF KickVersion(39)
  102.     DeletePool(pool)
  103.   ELSEIF pool<>NIL
  104. #endif
  105. #ifdef TEST
  106.   IF pool<>NIL
  107. #endif
  108.     WHILE Not(IsListEmpty(pool::lh))
  109.       mh:=pool::lh.head
  110.       Remove(mh)
  111.       freeMemHeader(mh)
  112.     ENDWHILE
  113.     #ifdef DEBUG
  114.       kputfmt('MEMPOOL disposed at $\h\n',[pool])
  115.     #endif
  116.     FreeMem(pool,SIZEOF pool)
  117.   ENDIF
  118. ENDPROC
  119.  
  120. /**
  121. ***  LibAllocPooled() is the AllocPooled() equivalent. In fact, it
  122. ***  calls AllocPooled(), if the OS is V39 or higher.
  123. **/
  124. PROC allocPuddle(pool:PTR TO pool,size)
  125.   DEF mh=NIL:PTR TO mh,poolsize
  126.  
  127.   poolsize:=Max(pool.puddlesize,(size+8))
  128.   IF (mh:=allocMemHeader(poolsize,pool.flags))=FALSE THEN RETURN FALSE
  129.   AddHead(pool::lh,mh)
  130. ENDPROC TRUE
  131.  
  132. EXPORT PROC libAllocPooled(pool:PTR TO pool,size)
  133.   DEF mh:PTR TO mh,newmem=NIL
  134.  
  135. #ifndef TEST
  136.   IF KickVersion(39) THEN RETURN AllocPooled(pool,size)
  137. #endif
  138.   IF (IsListEmpty(pool::lh)) OR (size>=pool.treshsize)
  139.     IF (allocPuddle(pool,size))=FALSE THEN RETURN NIL
  140.   ENDIF
  141.   #ifdef DEBUG
  142.     kputfmt('MEMPOOL alloc pool=$\h, flags=$\h, size=$\h\n',[pool,pool.flags,size])
  143.   #endif
  144.   mh:=pool::lh.head
  145.   WHILE (mh::ln.succ)
  146.     IF (newmem:=Allocate(mh,size))<>NIL THEN RETURN newmem
  147.     mh:=mh::ln.succ
  148.   ENDWHILE
  149.   IF (allocPuddle(pool,size))=FALSE THEN RETURN NIL
  150.   mh:=pool::lh.head
  151.   RETURN Allocate(mh,size)
  152. ENDPROC
  153.  
  154. /**
  155. ***  LibFreePooled() is the counterpart to LibAllocPooled().
  156. **/
  157. EXPORT PROC libFreePooled(pool:PTR TO pool,mem,size)
  158.   DEF mh:PTR TO mh
  159.  
  160.   IF mem=NIL THEN RETURN
  161. #ifndef TEST
  162.   IF KickVersion(39) THEN RETURN FreePooled(pool,mem,size)
  163. #endif
  164.   #ifdef DEBUG
  165.     kputfmt('MEMPOOL free pool=$\h, flags=$\h, size=$\h\n',[pool,pool.flags,size])
  166.   #endif
  167.   mh:=pool::lh.head
  168.   WHILE (mh::ln.succ)
  169.     IF (mem>=mh.lower) AND (mem<mh.upper)
  170.       RETURN Deallocate(mh,mem,size)
  171.     ENDIF
  172.     mh:=mh::ln.succ
  173.   ENDWHILE
  174. ENDPROC
  175.  
  176. EXPORT PROC libAllocVecPooled(pool:PTR TO pool,memSize)
  177.   DEF realSize,mem
  178.  
  179.   realSize:=memSize+4
  180.   IF (mem:=libAllocPooled(pool,realSize))=NIL THEN RETURN
  181.   MOVE.L mem,A0
  182.   MOVE.L realSize,D0
  183.   MOVE.L D0,(A0)+
  184.   MOVE.L A0,D0
  185. ENDPROC D0
  186.  
  187. EXPORT PROC libFreeVecPooled(pool:PTR TO pool,memory:PTR TO LONG)
  188.   DEF realSize
  189.  
  190.   MOVE.L memory,A0
  191.   MOVE.L -(A0),realSize
  192.   MOVE.L A0,memory
  193.   libFreePooled(pool,memory,realSize)
  194. ENDPROC
  195.